பாண்டாஸ் டேட்டாஃபிரேம் உருவாக்கும் கலையில் தேர்ச்சி பெறுங்கள். அகராதிகள், பட்டியல்கள், NumPy வரிசைகள் போன்றவற்றிலிருந்து டேட்டாஃபிரேம்களைத் தொடங்கும் முறைகளை இந்த வழிகாட்டி விவரிக்கிறது.
பாண்டாஸ் டேட்டாஃபிரேம் உருவாக்கம்: தரவுக் கட்டமைப்பை தொடங்குவதற்கான ஒரு ஆழமான பார்வை
பைத்தான் மூலம் தரவு கையாளுதலின் உலகிற்கு வரவேற்கிறோம்! கிட்டத்தட்ட ஒவ்வொரு தரவு பகுப்பாய்வுப் பணியின் மையத்திலும் பாண்டாஸ் லைப்ரரி உள்ளது, அதன் மூலக்கல் டேட்டாஃபிரேம் ஆகும். டேட்டாஃபிரேமை உங்கள் பைத்தான் சூழலுக்குள் இருக்கும் ஒரு விரிதாள் அல்லது தரவுத்தள அட்டவணையின் புத்திசாலித்தனமான, சக்திவாய்ந்த மற்றும் நெகிழ்வான பதிப்பாக நினையுங்கள். தரவை சுத்தம் செய்வதற்கும், மாற்றுவதற்கும், பகுப்பாய்வு செய்வதற்கும் மற்றும் காட்சிப்படுத்துவதற்கும் இது முதன்மை கருவியாகும். ஆனால் இந்த தரவு மாயாஜாலத்தை நீங்கள் செய்வதற்கு முன், முதலில் ஒரு டேட்டாஃபிரேமை உருவாக்கும் கலையில் தேர்ச்சி பெற வேண்டும். இந்த அடிப்படைக் தரவுக் கட்டமைப்பை நீங்கள் எவ்வாறு தொடங்குகிறீர்கள் என்பது உங்கள் முழு பகுப்பாய்விற்கும் களம் அமைக்கும்.
இந்த விரிவான வழிகாட்டி, ஆர்வமுள்ள மற்றும் பயிற்சிபெறும் தரவு ஆய்வாளர்கள், விஞ்ஞானிகள் மற்றும் பொறியாளர்களின் உலகளாவிய பார்வையாளர்களுக்காக வடிவமைக்கப்பட்டுள்ளது. பாண்டாஸ் டேட்டாஃபிரேம்களை புதிதாக உருவாக்குவதற்கான மிகவும் பொதுவான மற்றும் சக்திவாய்ந்த முறைகளை நாம் ஆராய்வோம். உங்கள் தரவு ஒரு அகராதியில், பட்டியலில், NumPy வரிசையில் அல்லது வேறு வடிவத்தில் இருந்தாலும், இந்த கட்டுரை உங்கள் டேட்டாஃபிரேம்களை நம்பிக்கையுடனும் திறமையுடனும் தொடங்குவதற்கான அறிவையும் நடைமுறை எடுத்துக்காட்டுகளையும் உங்களுக்கு வழங்கும். நமது அடித்தளத்தை உருவாக்குவோம்.
பாண்டாஸ் டேட்டாஃபிரேம் என்றால் என்ன?
நாம் உருவாக்கத் தொடங்குவதற்கு முன், நாம் எதைக் கட்டமைக்கிறோம் என்பதைத் தெளிவுபடுத்துவோம். பாண்டாஸ் டேட்டாஃபிரேம் என்பது இரு பரிமாண, அளவு மாற்றக்கூடிய மற்றும் பன்முகத்தன்மை கொண்ட அட்டவணை தரவுக் கட்டமைப்பாகும். அதை உடைத்துக் காண்போம்:
- இரு பரிமாண அமைப்பு: இது ஒரு விரிதாள் போல வரிசைகள் மற்றும் நெடுவரிசைகளைக் கொண்டுள்ளது.
- அளவு மாற்றக்கூடியது: டேட்டாஃபிரேம் உருவாக்கப்பட்ட பிறகு நீங்கள் வரிசைகளையும் நெடுவரிசைகளையும் சேர்க்கலாம் அல்லது அகற்றலாம்.
- பன்முகத்தன்மை: நெடுவரிசைகள் வெவ்வேறு தரவு வகைகளைக் கொண்டிருக்கலாம். உதாரணமாக, ஒரு நெடுவரிசையில் எண்கள் (முழு எண்கள் அல்லது மிதவை எண்கள்), மற்றொன்றில் உரை (சரங்கள்), மற்றும் மூன்றாவதில் தேதிகள் அல்லது பூலியன் மதிப்புகள் (True/False) இருக்கலாம்.
ஒரு டேட்டாஃபிரேமிற்கு மூன்று முக்கிய கூறுகள் உள்ளன:
- தரவு (The Data): கட்டமைப்பிற்குள் உள்ள உண்மையான மதிப்புகள், வரிசைகள் மற்றும் நெடுவரிசைகளில் ஒழுங்கமைக்கப்பட்டுள்ளன.
- வரிசை எண் (The Index): வரிசைகளுக்கான லேபிள்கள். நீங்கள் ஒரு வரிசை எண்ணை வழங்கவில்லை என்றால், பாண்டாஸ் 0-விலிருந்து தொடங்கும் ஒரு இயல்புநிலை ஒன்றை உருவாக்கும். வரிசை எண் தரவை அணுகுவதற்கும் சீரமைப்பதற்கும் ஒரு சக்திவாய்ந்த வழியை வழங்குகிறது.
- நெடுவரிசைகள் (The Columns): நெடுவரிசைகளுக்கான லேபிள்கள். டேட்டாஃபிரேமிற்குள் குறிப்பிட்ட தரவுத் தொடர்களை அணுகுவதற்கு இவை முக்கியமானவை.
இந்த கட்டமைப்பைப் புரிந்துகொள்வது, டேட்டாஃபிரேம்களை எவ்வாறு திறம்பட உருவாக்குவது மற்றும் கையாளுவது என்பதைப் புரிந்துகொள்வதற்கான திறவுகோலாகும்.
அடிப்படை: பாண்டாஸை இறக்குமதி செய்தல்
முதலில் செய்ய வேண்டியது. பாண்டாஸைப் பயன்படுத்த, உங்கள் பைத்தான் ஸ்கிரிப்ட் அல்லது நோட்புக்கில் லைப்ரரியை இறக்குமதி செய்ய வேண்டும். உலகெங்கிலும் உள்ள நிபுணர்களால் பின்பற்றப்படும் உலகளவில் ஏற்றுக்கொள்ளப்பட்ட வழக்கம், அதை pd என்ற மாற்றுப்பெயருடன் இறக்குமதி செய்வதாகும். இந்த எளிய மாற்றுப்பெயர் உங்கள் குறியீட்டை மேலும் படிக்கக்கூடியதாகவும் சுருக்கமாகவும் ஆக்குகிறது.
import pandas as pd
import numpy as np # பெரும்பாலும் பாண்டாஸுடன் பயன்படுத்தப்படுகிறது, எனவே அதையும் இறக்குமதி செய்வோம்.
இந்த ஒற்றை வரியின் மூலம், பாண்டாஸ் லைப்ரரியின் முழு சக்தியையும் நீங்கள் திறந்துவிட்டீர்கள். இப்போது, இந்த வழிகாட்டியின் மையக்கருத்திற்கு வருவோம்: டேட்டாஃபிரேம்களை உருவாக்குதல்.
முக்கிய உருவாக்கும் முறைகள்: எளிமையிலிருந்து சிக்கலானவை வரை
pd.DataFrame() கன்ஸ்ட்ரக்டர் நம்பமுடியாத அளவிற்கு பல்துறை வாய்ந்தது. இது பல வகையான உள்ளீடுகளை ஏற்க முடியும். இப்போது நாம் மிகவும் அவசியமான முறைகளை, மிகவும் பொதுவானவற்றிலிருந்து சிறப்பு வாய்ந்த நிகழ்வுகளுக்கு நகர்ந்து ஆராய்வோம்.
1. பட்டியல்கள் அல்லது வரிசைகளின் அகராதியிலிருந்து டேட்டாஃபிரேம் உருவாக்குதல்
டேட்டாஃபிரேம் உருவாக்குவதற்கான மிகவும் பொதுவான மற்றும் உள்ளுணர்வு முறை இதுவாகும். நீங்கள் ஒரு பைத்தான் அகராதியுடன் தொடங்குகிறீர்கள், அங்கு சாவிகள் (keys) நெடுவரிசைப் பெயர்களாக மாறும், மற்றும் மதிப்புகள் (values) ஒவ்வொரு நெடுவரிசைக்குமான தரவைக் கொண்ட பட்டியல்களாக (அல்லது NumPy வரிசைகள் அல்லது பாண்டாஸ் தொடர்களாக) இருக்கும்.
இது எப்படி வேலை செய்கிறது: பாண்டாஸ் ஒவ்வொரு அகராதிச் சாவியையும் ஒரு நெடுவரிசைத் தலைப்புடனும், ஒவ்வொரு மதிப்புகளின் பட்டியலையும் அந்த நெடுவரிசையின் வரிசைகளுடனும் இணைக்கிறது. இங்கு ஒரு முக்கியமான தேவை என்னவென்றால், அனைத்து பட்டியல்களும் ஒரே நீளத்தைக் கொண்டிருக்க வேண்டும், ஏனெனில் ஒவ்வொரு பட்டியலும் ஒரு முழு நெடுவரிசைத் தரவைக் குறிக்கிறது.
உதாரணம்:
உலகெங்கிலும் உள்ள வெவ்வேறு நகரங்களைப் பற்றிய தகவல்களைக் கொண்ட ஒரு டேட்டாஃபிரேமை உருவாக்குவோம்.
# நெடுவரிசைப்படி ஒழுங்கமைக்கப்பட்ட தரவு
city_data = {
'City': ['Tokyo', 'Delhi', 'Shanghai', 'São Paulo', 'Mumbai'],
'Country': ['Japan', 'India', 'China', 'Brazil', 'India'],
'Population_Millions': [37.3, 32.0, 28.5, 22.4, 20.9],
'Is_Coastal': [True, False, True, False, True]
}
# டேட்டாஃபிரேமை உருவாக்குதல்
df_from_dict = pd.DataFrame(city_data)
print(df_from_dict)
வெளியீடு:
City Country Population_Millions Is_Coastal
0 Tokyo Japan 37.3 True
1 Delhi India 32.0 False
2 Shanghai China 28.5 True
3 São Paulo Brazil 22.4 False
4 Mumbai India 20.9 True
முக்கிய குறிப்பு: உங்கள் தரவு அம்சம் அல்லது வகையின்படி இயற்கையாக ஒழுங்கமைக்கப்பட்டிருக்கும்போது இந்த முறை சரியானது. இது சுத்தமானது, படிக்கக்கூடியது, மற்றும் உங்கள் அகராதியின் கட்டமைப்பை நேரடியாக ஒரு அட்டவணை வடிவத்திற்கு மாற்றுகிறது.
2. அகராதிகளின் பட்டியலிலிருந்து டேட்டாஃபிரேம் உருவாக்குதல்
ஒரு மாற்று மற்றும் சமமாக சக்திவாய்ந்த முறை, ஒவ்வொரு கூறும் ஒரு அகராதியாக இருக்கும் பட்டியலைப் பயன்படுத்துவதாகும். இந்த கட்டமைப்பில், ஒவ்வொரு அகராதியும் ஒரு வரிசையைக் குறிக்கிறது, மேலும் அதன் சாவிகள் அந்த வரிசையின் தரவிற்கான நெடுவரிசைப் பெயர்களைக் குறிக்கின்றன.
இது எப்படி வேலை செய்கிறது: பாண்டாஸ் பட்டியலின் வழியாகச் செல்கிறது. ஒவ்வொரு அகராதிக்கும், அது ஒரு புதிய வரிசையை உருவாக்குகிறது. நெடுவரிசைகளைத் தீர்மானிக்க அகராதி சாவிகள் பயன்படுத்தப்படுகின்றன. இந்த முறை நம்பமுடியாத அளவிற்கு நெகிழ்வானது, ஏனெனில் ஒரு அகராதியில் ஒரு சாவி இல்லை என்றால், பாண்டாஸ் தானாகவே அந்த கலத்தை தொடர்புடைய வரிசையில் NaN (Not a Number) உடன் நிரப்பும், இது பாண்டாஸில் விடுபட்ட தரவிற்கான நிலையான குறியீடாகும்.
உதாரணம்:
அதே நகரத் தரவை மீண்டும் குறிப்பிடுவோம், ஆனால் இந்த முறை பதிவுகளின் பட்டியலாக கட்டமைக்கப்பட்டுள்ளது.
# வரிசைப்படி (பதிவு) ஒழுங்கமைக்கப்பட்ட தரவு
records_data = [
{'City': 'Tokyo', 'Country': 'Japan', 'Population_Millions': 37.3, 'Is_Coastal': True},
{'City': 'Delhi', 'Country': 'India', 'Population_Millions': 32.0, 'Is_Coastal': False},
{'City': 'Shanghai', 'Country': 'China', 'Population_Millions': 28.5},
{'City': 'São Paulo', 'Country': 'Brazil', 'Population_Millions': 22.4, 'Is_Coastal': False},
{'City': 'Cairo', 'Country': 'Egypt', 'Timezone': 'EET'} # வேறுபட்ட கட்டமைப்பைக் கவனிக்கவும்
]
# டேட்டாஃபிரேமை உருவாக்குதல்
df_from_list_of_dicts = pd.DataFrame(records_data)
print(df_from_list_of_dicts)
வெளியீடு:
City Country Population_Millions Is_Coastal Timezone
0 Tokyo Japan 37.3 True NaN
1 Delhi India 32.0 False NaN
2 Shanghai China 28.5 NaN NaN
3 São Paulo Brazil 22.4 False NaN
4 Cairo Egypt NaN NaN EET
பாண்டாஸ் முரண்பாடுகளை எவ்வாறு அழகாக கையாண்டது என்பதைக் கவனியுங்கள். ஷாங்காய்க்கான 'Is_Coastal' மதிப்பு அதன் அகராதியில் இல்லாததால் NaN ஆகும். கெய்ரோவிற்கு ஒரு புதிய 'Timezone' நெடுவரிசை உருவாக்கப்பட்டது, மற்ற எல்லா நகரங்களுக்கும் NaN உடன். இது APIகளிலிருந்து வரும் JSON பதில்கள் போன்ற பகுதி-கட்டமைக்கப்பட்ட தரவுகளுடன் வேலை செய்வதற்கு ஒரு சிறந்த தேர்வாக அமைகிறது.
முக்கிய குறிப்பு: உங்கள் தரவு பதிவுகள் அல்லது அவதானிப்புகளின் தொடராக வரும்போது இந்த முறையைப் பயன்படுத்தவும். இது விடுபட்ட தரவு மற்றும் பதிவு கட்டமைப்பில் உள்ள மாறுபாடுகளைக் கையாள்வதில் வலுவானது.
3. NumPy வரிசையிலிருந்து டேட்டாஃபிரேம் உருவாக்குதல்
அறிவியல் கணினி, இயந்திர கற்றல் அல்லது அதிக எண் செயல்பாடுகளை உள்ளடக்கிய எந்தத் துறையிலும் பணிபுரிபவர்களுக்கு, தரவு பெரும்பாலும் NumPy வரிசைகளில் இருந்து உருவாகிறது. பாண்டாஸ் NumPy-யின் மேல் கட்டமைக்கப்பட்டுள்ளது, இது இரண்டிற்கும் இடையேயான ஒருங்கிணைப்பை தடையற்றதாகவும் மிகவும் திறமையாகவும் ஆக்குகிறது.
இது எப்படி வேலை செய்கிறது: நீங்கள் ஒரு 2D NumPy வரிசையை pd.DataFrame() கன்ஸ்ட்ரக்டருக்கு அனுப்புகிறீர்கள். இயல்பாக, பாண்டாஸ் முழு எண் அடிப்படையிலான வரிசை எண்கள் மற்றும் நெடுவரிசைகளை உருவாக்கும். இருப்பினும், நீங்கள் index மற்றும் columns அளவுருக்களைப் பயன்படுத்தி அர்த்தமுள்ள லேபிள்களை வழங்கலாம் (மற்றும் வழங்க வேண்டும்).
உதாரணம்:
நேரப்போக்கில் சென்சார் அளவீடுகளைக் குறிக்கும், தோராயமாக உருவாக்கப்பட்ட 5x4 NumPy வரிசையிலிருந்து ஒரு டேட்டாஃபிரேமை உருவாக்குவோம்.
# தோராயமான தரவுகளுடன் 5x4 NumPy வரிசையை உருவாக்குதல்
data_np = np.random.rand(5, 4)
# நெடுவரிசை மற்றும் வரிசை எண் லேபிள்களை வரையறுத்தல்
columns = ['Sensor_A', 'Sensor_B', 'Sensor_C', 'Sensor_D']
index = pd.to_datetime(['2023-10-27 10:00', '2023-10-27 10:01', '2023-10-27 10:02', '2023-10-27 10:03', '2023-10-27 10:04'])
# டேட்டாஃபிரேமை உருவாக்குதல்
df_from_numpy = pd.DataFrame(data=data_np, index=index, columns=columns)
print(df_from_numpy)
வெளியீடு (உங்கள் தோராயமான எண்கள் வேறுபடலாம்):
Sensor_A Sensor_B Sensor_C Sensor_D
2023-10-27 10:00:00 0.123456 0.987654 0.555555 0.111111
2023-10-27 10:01:00 0.234567 0.876543 0.666666 0.222222
2023-10-27 10:02:00 0.345678 0.765432 0.777777 0.333333
2023-10-27 10:03:00 0.456789 0.654321 0.888888 0.444444
2023-10-27 10:04:00 0.567890 0.543210 0.999999 0.555555
இந்த எடுத்துக்காட்டில், நாம் ஒரு சக்திவாய்ந்த அம்சத்தையும் அறிமுகப்படுத்தினோம்: நேரத் தொடர் தரவுகளுக்கு DatetimeIndex-ஐப் பயன்படுத்துவது, இது பாண்டாஸில் நேர அடிப்படையிலான பகுப்பாய்வுத் திறன்களின் ஒரு பரந்த வரிசையைத் திறக்கிறது.
முக்கிய குறிப்பு: ஒரே மாதிரியான எண் தரவுகளிலிருந்து ஒரு டேட்டாஃபிரேமை உருவாக்குவதற்கான நினைவக-திறமையான முறை இதுவாகும். NumPy, Scikit-learn, அல்லது TensorFlow போன்ற லைப்ரரிகளுடன் இடைமுகம் செய்யும்போது இது நிலையான தேர்வாகும்.
4. பட்டியல்களின் பட்டியலிலிருந்து டேட்டாஃபிரேம் உருவாக்குதல்
இந்த முறை ஒரு NumPy வரிசையிலிருந்து உருவாக்குவதைப் போன்றது, ஆனால் நிலையான பைத்தான் பட்டியல்களைப் பயன்படுத்துகிறது. ஒரு உட்பொதிந்த பட்டியல் வடிவத்தில் சேமிக்கப்பட்ட அட்டவணைத் தரவை மாற்றுவதற்கான ஒரு நேரடியான வழி இது.
இது எப்படி வேலை செய்கிறது: நீங்கள் ஒரு பட்டியலை வழங்குகிறீர்கள், அங்கு ஒவ்வொரு உள் பட்டியலும் ஒரு வரிசைத் தரவைக் குறிக்கிறது. NumPy வரிசைகளைப் போலவே, தெளிவுக்காக columns அளவுரு வழியாக நெடுவரிசைப் பெயர்களைக் குறிப்பிடுவது மிகவும் பரிந்துரைக்கப்படுகிறது.
உதாரணம்:
# வரிசைகளின் பட்டியலாக தரவு
product_data = [
['P001', 'Laptop', 1200.00, 'Electronics'],
['P002', 'Mouse', 25.50, 'Electronics'],
['P003', 'Desk Chair', 150.75, 'Furniture'],
['P004', 'Keyboard', 75.00, 'Electronics']
]
# நெடுவரிசைப் பெயர்களை வரையறுத்தல்
column_names = ['ProductID', 'ProductName', 'Price_USD', 'Category']
# டேட்டாஃபிரேமை உருவாக்குதல்
df_from_list_of_lists = pd.DataFrame(product_data, columns=column_names)
print(df_from_list_of_lists)
வெளியீடு:
ProductID ProductName Price_USD Category 0 P001 Laptop 1200.00 Electronics 1 P002 Mouse 25.50 Electronics 2 P003 Desk Chair 150.75 Furniture 3 P004 Keyboard 75.00 Electronics
முக்கிய குறிப்பு: உங்கள் தரவு ஏற்கனவே வரிசைகளின் பட்டியலாக கட்டமைக்கப்பட்டிருக்கும்போது, அதாவது தலைப்புகள் இல்லாத கோப்பு வடிவத்திலிருந்து படிக்கும்போது, இது ஒரு எளிய மற்றும் பயனுள்ள முறையாகும்.
மேம்பட்ட தொடக்கம்: உங்கள் டேட்டாஃபிரேமைத் தனிப்பயனாக்குதல்
மூலத் தரவை வழங்குவதைத் தாண்டி, pd.DataFrame() கன்ஸ்ட்ரக்டர் உங்கள் புதிய டேட்டாஃபிரேமின் கட்டமைப்பு மற்றும் பண்புகளை அது உருவாக்கப்பட்ட தருணத்திலிருந்தே கட்டுப்படுத்த பல அளவுருக்களை வழங்குகிறது.
வரிசை எண்ணைக் குறிப்பிடுதல்
நாம் ஏற்கனவே `index` அளவுருவை செயல்பாட்டில் பார்த்துள்ளோம். வரிசை எண் என்பது டேட்டாஃபிரேமின் ஒரு முக்கிய பகுதியாகும், இது வரிசைகளுக்கு லேபிள்களை வழங்குகிறது, அவை வேகமான தேடல்கள், தரவு சீரமைப்பு மற்றும் பலவற்றிற்குப் பயன்படுத்தப்படுகின்றன. பாண்டாஸ் ஒரு இயல்புநிலை எண் வரிசை எண்ணை (0, 1, 2, ...) வழங்கினாலும், ஒரு அர்த்தமுள்ள வரிசை எண்ணை அமைப்பது உங்கள் தரவை வேலை செய்வதற்கு மிகவும் எளிதாக்கும்.
உதாரணம்: நமது பட்டியல்களின் அகராதி உதாரணத்தை மீண்டும் பயன்படுத்துவோம், ஆனால் `City` நெடுவரிசையை உருவாக்கும்போதே வரிசை எண்ணாக அமைப்போம்.
city_data = {
'Country': ['Japan', 'India', 'China', 'Brazil', 'India'],
'Population_Millions': [37.3, 32.0, 28.5, 22.4, 20.9],
'Is_Coastal': [True, False, True, False, True]
}
city_names = ['Tokyo', 'Delhi', 'Shanghai', 'São Paulo', 'Mumbai']
# தனிப்பயன் வரிசை எண்ணுடன் டேட்டாஃபிரேமை உருவாக்குதல்
df_with_index = pd.DataFrame(city_data, index=city_names)
print(df_with_index)
வெளியீடு:
Country Population_Millions Is_Coastal
Tokyo Japan 37.3 True
Delhi India 32.0 False
Shanghai China 28.5 True
São Paulo Brazil 22.4 False
Mumbai India 20.9 True
இப்போது, நீங்கள் இந்த அர்த்தமுள்ள லேபிள்களைப் பயன்படுத்தி வரிசைத் தரவை அணுகலாம், உதாரணமாக, df_with_index.loc['Tokyo'] உடன்.
தரவு வகைகளைக் கட்டுப்படுத்துதல் (`dtype`)
பாண்டாஸ் தரவு வகைகளை (எ.கா., எண்கள், உரை, மற்றும் பூலியன்களை அங்கீகரிப்பது) ஊகிப்பதில் மிகவும் சிறந்தது. இருப்பினும், சில நேரங்களில் நினைவகத் திறனை உறுதிப்படுத்த அல்லது குறிப்பிட்ட செயல்பாடுகளை இயக்க ஒரு நெடுவரிசைக்கு ஒரு குறிப்பிட்ட தரவு வகையை நீங்கள் கட்டாயப்படுத்த வேண்டும். `dtype` அளவுரு உங்களுக்கு இந்த கட்டுப்பாட்டைக் கொடுக்கிறது.
உதாரணம்: நம்மிடம் எண்கள் போலத் தோன்றும் ஆனால் உரையாக (சரங்கள்) கருதப்பட வேண்டிய தயாரிப்பு ஐடிகள் இருப்பதாக கற்பனை செய்து பாருங்கள்.
data = {
'ProductID': [101, 102, 103],
'Stock': [50, 75, 0]
}
# 'ProductID' க்கு ஒரு dtype ஐ குறிப்பிடும்போது டேட்டாஃபிரேமை உருவாக்குதல்
df_types = pd.DataFrame(data, dtype={'ProductID': str, 'Stock': 'int32'})
print(df_types.dtypes)
வெளியீடு:
ProductID object Stock int32 dtype: object
பாண்டாஸில் `str` என்பது `object` ஆக குறிப்பிடப்படுவதைக் கவனியுங்கள். `dtype`-ஐ வெளிப்படையாக அமைப்பதன் மூலம், `ProductID`-ஐ ஒரு எண்ணாக பாண்டாஸ் கருதுவதை நாம் தடுக்கிறோம், இது தவறான கணக்கீடுகள் அல்லது வரிசையாக்க சிக்கல்களுக்கு வழிவகுக்கும். இயல்புநிலை `int64`-க்கு பதிலாக `int32` போன்ற குறிப்பிட்ட முழு எண் வகைகளைப் பயன்படுத்துவது பெரிய தரவுத்தொகுப்புகளுடன் குறிப்பிடத்தக்க நினைவகத்தை சேமிக்க முடியும்.
நடைமுறைச் சூழல்கள் மற்றும் சிறந்த பழக்கவழக்கங்கள்
சரியான உருவாக்கும் முறையைத் தேர்ந்தெடுப்பது உங்கள் தரவின் அசல் வடிவத்தைப் பொறுத்தது. இங்கே ஒரு எளிய முடிவு வழிகாட்டி உள்ளது:
- உங்கள் தரவு நெடுவரிசைகளில் உள்ளதா (எ.கா., ஒவ்வொரு அம்சத்திற்கும் ஒரு பட்டியல்)? பட்டியல்களின் அகராதியைப் பயன்படுத்தவும். இது ஒரு இயற்கையான பொருத்தம்.
- உங்கள் தரவு பதிவுகளின் தொடரா (எ.கா., ஒரு JSON API இலிருந்து)? அகராதிகளின் பட்டியலைப் பயன்படுத்தவும். இது பதிவுகளில் விடுபட்ட அல்லது கூடுதல் புலங்களைக் கையாள்வதில் சிறந்து விளங்குகிறது.
- உங்கள் தரவு எண் மற்றும் ஒரு கட்டத்தில் உள்ளதா (எ.கா., ஒரு அறிவியல் கணக்கீட்டிலிருந்து)? ஒரு NumPy வரிசையைப் பயன்படுத்தவும். இந்த பயன்பாட்டு வழக்கிற்கு இது மிகவும் செயல்திறன் மிக்க விருப்பமாகும்.
- உங்கள் தரவு தலைப்புகள் இல்லாமல் ஒரு எளிய வரிசைக்கு வரிசை அட்டவணை வடிவத்தில் உள்ளதா? பட்டியல்களின் பட்டியலைப் பயன்படுத்தி நெடுவரிசைப் பெயர்களைத் தனியாக வழங்கவும்.
தவிர்க்க வேண்டிய பொதுவான தவறுகள்
- பட்டியல்களின் அகராதியில் சமமற்ற நீளங்கள்: இது ஒரு பொதுவான பிழை. பட்டியல்களின் அகராதியிலிருந்து ஒரு டேட்டாஃபிரேமை உருவாக்கும்போது, ஒவ்வொரு பட்டியலும் சரியான ஒரே எண்ணிக்கையிலான கூறுகளைக் கொண்டிருக்க வேண்டும். இல்லையெனில், பாண்டாஸ் ஒரு `ValueError`-ஐ எழுப்பும். உருவாக்குவதற்கு முன் உங்கள் நெடுவரிசைத் தரவு சம நீளத்தில் இருப்பதை எப்போதும் உறுதிப்படுத்திக் கொள்ளுங்கள்.
- வரிசை எண்ணைப் புறக்கணித்தல்: இயல்புநிலை 0-அடிப்படையிலான வரிசை எண்ணை நம்பியிருப்பது பல நிகழ்வுகளுக்கு நல்லது, ஆனால் உங்கள் தரவில் ஒரு இயற்கை அடையாளங்காட்டி (தயாரிப்பு ஐடி, பயனர் ஐடி, அல்லது ஒரு குறிப்பிட்ட நேரமுத்திரை போன்றவை) இருந்தால், அதை தொடக்கத்திலிருந்தே வரிசை எண்ணாக அமைப்பது உங்கள் குறியீட்டை பின்னர் எளிதாக்கும்.
- தரவு வகைகளை மறந்துவிடுதல்: பாண்டாஸ் வகைகளை ஊகிக்க விடுவது பெரும்பாலான நேரங்களில் வேலை செய்யும், ஆனால் பெரிய தரவுத்தொகுப்புகள் அல்லது கலப்பு வகைகளைக் கொண்ட நெடுவரிசைகளுக்கு, செயல்திறன் பாதிக்கப்படலாம். நினைவகத்தைச் சேமிக்கவும் பிழைகளைத் தடுக்கவும் வகைகளாக, சரங்களாக, அல்லது குறிப்பிட்ட எண் வகைகளாகக் கருதப்பட வேண்டிய நெடுவரிசைகளுக்கு `dtype`-ஐ முன்கூட்டியே அமைப்பதில் முனைப்புடன் இருங்கள்.
தொடக்கத்தைத் தாண்டி: கோப்புகளிலிருந்து டேட்டாஃபிரேம்களை உருவாக்குதல்
இந்த வழிகாட்டி நினைவகத்தில் உள்ள பைத்தான் ஆப்ஜெக்ட்களிலிருந்து டேட்டாஃபிரேம்களை உருவாக்குவதில் கவனம் செலுத்தினாலும், பெரும்பாலான நிஜ-உலக சூழ்நிலைகளில், உங்கள் தரவு ஒரு வெளிப்புறக் கோப்பிலிருந்து வரும் என்பதை அறிவது முக்கியம். பாண்டாஸ் இந்த நோக்கத்திற்காக மிகவும் உகந்ததாக்கப்பட்ட ரீடர் செயல்பாடுகளின் தொகுப்பை வழங்குகிறது, அவற்றுள்:
pd.read_csv(): காற்புள்ளியால் பிரிக்கப்பட்ட மதிப்புகள் கோப்புகளுக்கு, தரவு இறக்குமதியின் முக்கிய கருவி.pd.read_excel(): மைக்ரோசாப்ட் எக்செல் விரிதாள்களிலிருந்து தரவைப் படிக்க.pd.read_json(): JSON கோப்புகள் அல்லது சரங்களிலிருந்து தரவைப் படிக்க.pd.read_sql(): ஒரு தரவுத்தள வினவலின் முடிவுகளை நேரடியாக ஒரு டேட்டாஃபிரேமில் படிக்க.pd.read_parquet(): திறமையான, நெடுவரிசை சார்ந்த Parquet கோப்பு வடிவத்திலிருந்து படிக்க.
இந்த செயல்பாடுகள் உங்கள் பாண்டாஸ் பயணத்தில் அடுத்த தர்க்கரீதியான படியாகும். அவற்றில் தேர்ச்சி பெறுவது, கிட்டத்தட்ட எந்த மூலத்திலிருந்தும் தரவை ஒரு சக்திவாய்ந்த டேட்டாஃபிரேம் கட்டமைப்பில் உட்கொள்ள உங்களை அனுமதிக்கும்.
முடிவுரை: தரவு நிபுணத்துவத்திற்கான உங்கள் அடித்தளம்
பாண்டாஸ் டேட்டாஃபிரேம் பைத்தானில் எந்தவொரு தீவிரமான தரவுப் பணிக்கும் மையத் தரவுக் கட்டமைப்பாகும். நாம் பார்த்தது போல், பாண்டாஸ் இந்த கட்டமைப்புகளை பல்வேறு வடிவங்களிலிருந்து தொடங்குவதற்கு ஒரு நெகிழ்வான மற்றும் உள்ளுணர்வு கருவிகளின் தொகுப்பை வழங்குகிறது. அகராதிகள், பட்டியல்கள் மற்றும் NumPy வரிசைகளிலிருந்து ஒரு டேட்டாஃபிரேமை எவ்வாறு உருவாக்குவது என்பதைப் புரிந்துகொள்வதன் மூலம், உங்கள் தரவு பகுப்பாய்வுத் திட்டங்களுக்கு ஒரு திடமான அடித்தளத்தை நீங்கள் உருவாக்கியுள்ளீர்கள்.
முக்கியமானது உங்கள் தரவின் அசல் அமைப்புடன் சிறந்த முறையில் பொருந்தக்கூடிய முறையைத் தேர்ந்தெடுப்பதாகும். இது உங்கள் குறியீட்டை சுத்தமாகவும், படிக்கக்கூடியதாகவும் ஆக்குவதோடு மட்டுமல்லாமல், மேலும் திறமையாகவும் ஆக்குகிறது. இங்கிருந்து, தரவு சுத்தம் செய்தல், ஆய்வு, மாற்றம் மற்றும் காட்சிப்படுத்தல் ஆகியவற்றின் அற்புதமான பணிகளுக்குச் செல்ல நீங்கள் தயாராக உள்ளீர்கள். மகிழ்ச்சியான கோடிங்!